package com.example.liuke.guangguang.ui;

import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import com.example.liuke.guangguang.R;
import com.example.liuke.guangguang.base.baseactivity;
import com.example.liuke.guangguang.bean.User;
import com.example.liuke.guangguang.bean.mseeagebean;
import com.example.liuke.guangguang.db.dbuntils.DaoOpe;
import com.example.liuke.guangguang.db.dbuntils.DbManager;

import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

import java.util.ArrayList;
import java.util.List;

import butterknife.BindView;
import butterknife.OnClick;

/**
 * 数据库GreenDao的使用示例
 *
 * @author liuke
 * @time 2018/9/17 14:04
 */
public class GreenDaoActivity extends baseactivity {

    @BindView(R.id.dbbutton)
    Button button;
    @BindView(R.id.dbbutton2)
    Button button2;
    @BindView(R.id.dbbutton3)
    Button button3;
    @BindView(R.id.dbbutton4)
    Button button4;
    @BindView(R.id.btn_query_all)
    Button btnQueryAll;
    @BindView(R.id.dbbutton5)
    Button button5;
    @BindView(R.id.tv_content)
    TextView tvContent;
    @BindView(R.id.conditionbutton)
    Button conditionbutton;
    @BindView(R.id.update)
    Button update;
    @BindView(R.id.insertorreplace)
    Button insertorreplace;
    @BindView(R.id.back)
    Button back;
    private List<User> usersList = new ArrayList<>();
    int page;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //initdate();
    }

    @Override
    protected int getLayoutId() {
        return R.layout.activity_green_dao;
    }

    @OnClick({R.id.dbbutton, R.id.dbbutton2, R.id.dbbutton3, R.id.dbbutton4, R.id.btn_query_all,
            R.id.dbbutton5, R.id.conditionbutton, R.id.update, R.id.insertorreplace,R.id.back})
    public void onViewClicked(View view) {
        switch (view.getId()) {
            case R.id.dbbutton:
                usersList.clear();
                initdate();
                DaoOpe.insertData(this, usersList);
                break;
            case R.id.dbbutton2:
                User user = new User((long) 5, "haung" + 5, "123456");
                /**
                 * 根据特定的对象删除
                 */
                DaoOpe.deleteData(this, user);
                /**
                 * 根据主键删除
                 */
                //DaoOpe.deleteByKeyData(this, 7);
                break;
            case R.id.dbbutton3://1098  / 66698 / huang98
                User user1 = new User((long) 1098, null, "123456");
                DaoOpe.updateData(this, user1);
                break;
            case R.id.dbbutton4://查
                List<User> students = DaoOpe.queryAll(this);
                String te = "";
                for (int i = 0; i < students.size(); i++) {
                    te += students.get(i).getId() + "/" + students.get(i).getUsername() + "/" + students.get(i).getNickname() + "\n";
                    System.out.println("Log: " + students.size() + "  具体" + students.get(i).getId() + "  / " + students.get(i).getNickname() + " / " + students.get(i).getUsername());
                }
                tvContent.setText(te);
                break;
            case R.id.btn_query_all:
                List<User> students2 = DaoOpe.queryPaging(page, 20, this);
                if (students2.size() == 0) {
                    Toast.makeText(this, "没有更多数据了", Toast.LENGTH_SHORT).show();
                }
                page++;
                tvContent.setText(students2.toString());
                break;
            case R.id.dbbutton5://删除之后id还是接连上次删除的id自增的，没有重置
                DaoOpe.deleteAllData(this);
                break;
            case R.id.conditionbutton:
                List<User> list = DaoOpe.queryconditions(this);
                String text = "";
                for (User user2 : list) {
                    text += user2.getId() + "/" + user2.getUsername() + "/" + user2.getNickname() + "\n";
                }
                tvContent.setText(text);
                break;
            case R.id.update:
                DaoOpe.update(this);
                break;
            case R.id.insertorreplace:
                DaoOpe.update2(this);
                break;
            case R.id.back:
                DbManager.closeConnection();
                finish();
                break;
        }
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMoonEvent(mseeagebean mseeagebean) {

    }

    private void initdate() {
        for (int i = 0; i < 100; i++) {
            User user = new User(null, "huang" + i, "666" + i);
            usersList.add(user);
        }
    }


/*
    void 	attachEntity(T entity)：

    long 	count()：获取数据库中数据的数量

    // 数据删除相关
    void 	delete(T entity)：从数据库中删除给定的实体
    void 	deleteAll() ：删除数据库中全部数据
    void 	deleteByKey(K key)：从数据库中删除给定Key所对应的实体
    void 	deleteByKeyInTx(java.lang.Iterable<K> keys)：使用事务操作删除数据库中给定的所有key所对应的实体
    void 	deleteByKeyInTx(K... keys)：使用事务操作删除数据库中给定的所有key所对应的实体
    void 	deleteInTx(java.lang.Iterable<T> entities)：使用事务操作删除数据库中给定实体集合中的实体
    void 	deleteInTx(T... entities)：使用事务操作删除数据库中给定的实体

    // 数据插入相关
    long 	insert(T entity)：将给定的实体插入数据库 insert不能插入相同的数据
    void 	insertInTx(java.lang.Iterable<T> entities)：使用事务操作，将给定的实体集合插入数据库
    void 	insertInTx(java.lang.Iterable<T> entities, boolean setPrimaryKey)：使用事务操作，将给定的实体集合插入数据库，
    并设置是否设定主键
    void 	insertInTx(T... entities)：将给定的实体插入数据库
    long 	insertOrReplace(T entity)：将给定的实体插入数据库，若此实体类存在，则覆盖
    void 	insertOrReplaceInTx(java.lang.Iterable<T> entities)：使用事务操作，将给定的实体插入数据库，若此实体类存在，则覆盖 是否会跟新还不知道？？？
    void 	insertOrReplaceInTx(java.lang.Iterable<T> entities, boolean setPrimaryKey)：使用事务操作，将给定的实体插入数据库，若此实体类存在，则覆盖
            并设置是否设定主键
    void 	insertOrReplaceInTx(T... entities)：使用事务操作，将给定的实体插入数据库，若此实体类存在，则覆盖
    long 	insertWithoutSettingPk(T entity)：将给定的实体插入数据库,但不设定主键

    // 新增数据插入相关API
    void 	save(T entity)：将给定的实体插入数据库，若此实体类存在，则更新
    void 	saveInTx(java.lang.Iterable<T> entities)：将给定的实体插入数据库，若此实体类存在，则更新
    void 	saveInTx(T... entities)：使用事务操作，将给定的实体插入数据库，若此实体类存在，则更新

    // 加载相关
    T 	load(K key)：加载给定主键的实体
    java.util.List<T> 	loadAll()：加载数据库中所有的实体
    protected java.util.List<T> 	loadAllAndCloseCursor(android.database.Cursor cursor) ：从cursor中读取、返回实体的列表，并关闭该cursor
    protected java.util.List<T> 	loadAllFromCursor(android.database.Cursor cursor)：从cursor中读取、返回实体的列表
    T 	loadByRowId(long rowId) ：加载某一行并返回该行的实体
    protected T 	loadUnique(android.database.Cursor cursor) ：从cursor中读取、返回唯一实体
    protected T 	loadUniqueAndCloseCursor(android.database.Cursor cursor) ：从cursor中读取、返回唯一实体，并关闭该cursor
    //更新数据
    void 	update(T entity) ：更新给定的实体
    protected void 	updateInsideSynchronized(T entity, DatabaseStatement stmt, boolean lock)
    protected void 	updateInsideSynchronized(T entity, android.database.sqlite.SQLiteStatement stmt, boolean lock)
    void 	updateInTx(java.lang.Iterable<T> entities) ：使用事务操作，更新给定的实体
    void 	updateInTx(T... entities)：使用事务操作，更新给定的实体*/
}
